import { getNewCartGoods, reqFindCartList, reqMergeLocalCart, reqInsertCart, reqDeleteCart, reqUpdateCartSku, reqCheckAllCart } from '@/api/cart'
export default {
  // 模块里的state 需要用一个函数返回
  namespaced: true,
  state: () => {
    return {
      list: []
    }
  },
  getters: {
    // 计算有效商品列表 isEffective = true  stock>0
    effectiveList (state) {
      return state.list.filter(item => item.stock > 0 && item.isEffective)
    },
    // 总数量
    //  getters 里 有四个形参 （state，getters，rootState，rootGetters）
    effectiveTotal (state, getters) {
      return getters.effectiveList.reduce((sum, item) => sum + item.count, 0)
    },
    // 总价
    effectiveTotalPrice (state, getters) {
      return getters.effectiveList.reduce((sum, item) => sum + item.count * item.nowPrice, 0).toFixed(2)
    },
    // 计算无效商品列表
    ineffectiveList (state) {
      return state.list.filter(item => !(item.stock > 0 && item.isEffective))
    },
    // 有效商品的全选按钮
    isAllEffectSelected (state, getters) {
      // 所有的有效列表全选中，才返回treu
      return (getters.effectiveList.every(item => item.selected)) && getters.effectiveList.length > 0
    },
    // 已选中的有效商品列表(筛选出无效列表)
    SelectedList (state, getters) {
      return getters.effectiveList.filter(item => item.selected)
    },
    // 已选中商品的总数
    selectedAllCounts (state, getters) {
      return getters.SelectedList.reduce((sum, item) => sum + item.count, 0)
    },
    // 已选中商品的总价
    selectedAllPrice (state, getters) {
      return getters.SelectedList.reduce((sum, item) => sum + item.count * item.nowPrice, 0)
    }
  },
  mutations: {
    inserCart (state, payload) {
      // 添加购物车的逻辑
      // 1.如果有该商品，则直接加数量
      // 2.如果没有该商品，需要将该sku、添加到购物车
      // console.log('payload', payload)
      // 找到返回该项索引，找不到返回-1
      const sameIndex = state.list.findIndex(item => item.skuId === payload.skuId)
      // console.log(sameIndex)
      if (sameIndex >= 0) {
        state.list[sameIndex].count += payload.count
      } else {
        state.list.unshift(payload)
      }
    },
    deleteCart (state, payload) {
      state.list = state.list.filter(item => item.skuId !== payload)
    },
    updateCart (state, payload) {
      // 从购物车列表中找到，需要更新的sku
      const sku = state.list.find(item => item.skuId === payload.skuId)
      sku.isEffective = payload.isEffective
      sku.nowPrice = payload.nowPrice
      sku.stock = payload.stock
    },
    // 单选
    singCheck (state, { goods, selected }) {
      const sku = state.list.find(item => item.skuId === goods.skuId)
      // 找到哪个sku，就将哪个sku的selected属性同步
      sku.selected = selected
    },
    // 全选
    effectCheckAll (state, selected) {
      state.list.forEach(item => {
        if (item.isEffective && item.count > 0) {
          item.selected = selected
        }
      })
    },
    // 修改商品数量
    changeCount (state, { num, goods }) {
      const sku = state.list.find(item => item.skuId === goods.skuId)
      // 找到哪个sku，就将哪个sku的selected属性同步
      sku.count = num
    },
    // 获取登录后的最新数据，将后台合并后的购物车数据，重新赋值给本地的state
    setList (state, payload) {
      state.list = payload
    }
  },
  actions: {
    async inserCartAPI (context, payload) {
      // console.log(context.rootGetters.token)
      // rootState   根路径下的state 获取state，
      // rootGetters 根路径下的getters  获取getters
      // 通token 区分登录 和 未登录状态
      if (context.rootGetters.token) {
        console.log('已登录，走接口')
        const { skuId, count } = payload
        const res = await reqInsertCart({ skuId, count })
        console.log('加入购物车的数据', res.result)
        // 登录后获取最新的列表，替换本地的数据
        await context.dispatch('updateCartAPI')
      } else {
        // 未登录 走本地
        context.commit('inserCart', payload)
      }
    },
    // inserCartAPI (context, payload) {
    //   console.log(context.rootGetters.token)
    //   // rootState   根路径下的state 获取state，
    //   // rootGetters 根路径下的getters  获取getters
    //   return new Promise((resolve, reject) => {
    //     // 通token 区分登录 和 未登录状态
    //     if (context.rootGetters.token) {
    //       console.log('已登录，走接口')
    //       const { skuId, count } = payload
    //       reqInsertCart({skuId, count}).then(res => {
    //         console.log(res)
    //         resolve()
    //       })
    //     } else {
    //       // 未登录 走本地
    //       context.commit('inserCart', payload)
    //       resolve()
    //     }
    //   })
    // },
    async deleteCartAPI (context, payload) {
      // 通token 区分登录 和 未登录状态
      if (context.rootGetters.token) {
        console.log('已登录，走接口')
        await reqDeleteCart([payload])
        // 删除后获取最新的列表，替换本地的数据
        await context.dispatch('updateCartAPI')
      } else {
        // 未登录 走本地
        context.commit('deleteCart', payload)
      }
    },
    updateCartAPI (context) {
      return new Promise((resolve, reject) => {
        // 通token 区分登录 和 未登录状态
        if (context.rootGetters.token) {
          console.log('已登录，走接口')
          // 已登录，获取后台返回的最新的购物车列表数据
          // 异步调用的时候可以通过.then() 处理后续的逻辑 可能会加入成功给用户提示等等的操作
          reqFindCartList().then(res => {
            console.log('登录后获取信息', res)
            context.commit('setList', res.result)
            resolve()
          })
        } else {
          // 未登录 走本地
          // 没登录的时候，只要刷新页面了，就需要更新一下商品信息
          const requestArr = context.state.list.map(item => {
            return getNewCartGoods(item.skuId)
          })
          // Promise.all([1, 2, 3]).then()  1 , 2 ,3 三个异步方法都按照执行完才会进入.then()
          Promise.all(requestArr).then((values) => {
            console.log('values', values)
            values.forEach((item, index) => {
              context.commit('updateCart', {
                skuId: context.state.list[index].skuId,
                ...item.result
              })
            })
          })
          // 都请求完了，我们弹个message 告诉用户购物车商品更新了,.then(传入回调函数，)
          resolve()
        }
      })
    },
    singCheckAPI (context, { goods, selected }) {
      return new Promise((resolve, reject) => {
        // 通token 区分登录 和 未登录状态
        if (context.rootGetters.token) {
          console.log('已登录，走接口')
          reqUpdateCartSku({
            skuId: goods.skuId,
            selected: selected
          }).then(() => {
            // 删除后获取最新的列表，替换本地的数据
            context.dispatch('updateCartAPI')
          })
          resolve()
        } else {
          // 未登录 走本地
          context.commit('singCheck', { goods, selected })
          resolve()
        }
      })
    },
    // 全选
    effectCheckAllAPI (context, selected) {
      return new Promise((resolve, reject) => {
        // 通token 区分登录 和 未登录状态
        if (context.rootGetters.token) {
          console.log('已登录，走接口')
          // 获取 有效商品的skuId的集合
          const ids = context.getters.effectiveList.map(item => item.skuId)
          reqCheckAllCart({ selected, ids }).then(() => {
            // 删除后获取最新的列表，替换本地的数据
            context.dispatch('updateCartAPI')
          })
          resolve()
        } else {
          // 未登录 走本地
          context.commit('effectCheckAll', selected)
          resolve()
        }
      })
    },
    // 修改数量
    async changeCountAPI (context, { num, goods }) {
      // 通token 区分登录 和 未登录状态
      if (context.rootGetters.token) {
        console.log('已登录，走接口')
        await reqUpdateCartSku({
          skuId: goods.skuId,
          count: num
        })
        // 删除后获取最新的列表，替换本地的数据
        context.dispatch('updateCartAPI')
      } else {
        // 未登录 走本地
        context.commit('changeCount', { num, goods })
      }
    },
    // 合并购物车
    async mergeLocalCart (context) {
      // 直接将需要的数据结构出来，并且直接返回添加到新数组
      const cartList = context.state.list.map(({ skuId, selected, count }) =>
        ({ skuId, selected, count })
      )
      console.log('cartList', cartList)
      await reqMergeLocalCart(cartList)
      // 登录后获取最新的列表，替换本地的数据
      await context.dispatch('updateCartAPI')
    }
  }
}
